1. Field of Invention
The present invention relates to an improved system and method for configuring and executing a flexible computer program. More specifically, the invention relates to a system and method for specifying and combining a new type of component specification known as a component interface that is used to generate complex object structures and their interactions and that causes these objects to automatically interact according to the information contained in the component interfaces.
2. Description of Prior Art
As computers have become more powerful, software programs have become larger and more complex and, as a result, increasingly difficult to design and program. This is exacerbated in the business world where application programs are highly customized and must be frequently modified.
Unfortunately, once an application program has been created, it is often not easy to modify. Most application programs provide some means for using simple parameters to customize a program at execution time, but these are of limited flexibility. In most cases, modifications to the program logic require changes to the underlying program programming instructions, or source code.
Changes to program source code require great technical skill. Because of the complexity of program source code and the implicit business knowledge that is often buried within it, even the smallest program modification must be exhaustively tested. Furthermore, many business processes are duplicated across several different programs and must be synchronized.
As a result of these difficulties, a professional class of software engineers has emerged, few of who have more than a cursory knowledge of the business environment that the programs support. Meanwhile, very few business experts and program users are also programming experts.
Business requirements are usually communicated by business experts to software engineers for creation of program specifications and generation of programming source code. Since these two groups often xe2x80x9cspeak different languagesxe2x80x9d, such communication can be difficult, particularly when subject matter expertise is dispersed across an organization. Such miscommunication is compounded by inadequate documentation that is often dispersed and out of date.
As a result of these problems, many companies experience backlogs in application program development as a result of time spent making minor modifications. This delays the introduction of new business products and processes.
Perhaps the clearest indication of the impact of this can be seen in the so-called xe2x80x9cyear 2000 problemxe2x80x9d which arises from the convention of representing calendar years by their last two digits. As a result, many older application programs will be unable without modification to correctly process dates after the year 2000 . This fairly straightforward problem is easily defined, yet has proven costly and time-consuming to fix.
3. Recent Advances in Prior Art
Various advances have been made in the prior art to improve the software development process. These advances generally fall into one of several categories: i) techniques to assist in the design and documentation process (CASE tools), ii) visual programming tools and source code generators, iii) expert systems, and iv) object oriented programming.
Computer aided software engineering (CASE) design tools allow the software engineer to create visual representations of complex data relationships, data-flows, etc., that are used to generate detailed program specifications and to create documentation. These can then be used by the software engineer to assist in the coding of the computer program. CASE tools are not appropriate for non-technical business experts since they require proficiency with programming logic (such as iteration and conditional branching). Some CASE design tools are designed to aid in the specification of complex data structures and logical programming constructs. CASE Design tools do not eliminate the need to construct programming algorithms, nor do they improve the process by which business experts communicate business requirements to software engineers.
Visual programming tools typically facilitate the creation of the user interface of a program, by generating the source code for such elements as windows, buttons, checkboxes, menus, selection buttons, etc. Sometimes these tools can also be used to generate simple database applications. Visual programming tools can be used by a business expert with some minimal technical training as well as by software engineers. These tools can reduce the time spent on repetitive coding for well-defined objects with simple interfaces. However, since they do not eliminate the need to create the underlying programming logic, they are not suitable for use by non-technical business experts for anything beyond the simplest programs.
Expert systems share some of the objectives of the present invention, but are much more limited in scope. In general, such systems are used simply to abstract very specific and well-defined types of information (such as rules and decision trees) out of the program source code, but cannot address the full range of complex programming logic.
Object oriented programming has emerged as a promising technology that is designed to allow rapid development, implementation and customization of objects. Each new object has certain data attributes and processes or methods that operate on that data. Thus, program instructions are more tightly bound to the data upon which they operate than is the case with traditional programming languages. Data is said to be xe2x80x9cencapsulatedxe2x80x9d by an object and can only be modified by the object methods, which are invoked by sending a message to an object identifying the method and supplying any needed arguments.
Under the object-oriented approach, software engineers design object classes that represent general-purpose templates for executable objects. A computer program is built using source code that creates customized objects from these object classes and that specifies the interactions between the objects. Object classes often represent entities that can be easily described and understood, such as File, Account, Menu, Window, etc.
Object oriented systems have two important properties in addition to encapsulation. xe2x80x9cInheritancexe2x80x9d is the ability to derive a new object from an existing object and inherit all properties, including methods and data structure, from the existing object. The new object may have certain unique features that are supplied as overrides or modifications to the existing class. For example, a new subclass needs to specify only the functions and data that distinguish that class from the existing more general class. The ability to override an existing method description enables polymorphism, the ability to have a single message to an object be processed in different ways depending on the object itself. Inheritance and polymorphism create a powerful structure for implementing a new software system. The software developer does not have to develop each piece of a system; he or she need only specify the unique features of the system.
However, the promise of code re-use has proved to be difficult to achieve in practice. In order to use an object in a computer program, its attributes and its interactions with other objects must first be specified. This requires additional programming and can be time-consuming, particularly when these attributes and object iterations are complex. Also, object oriented programming is difficult, even for experienced software engineers. The dynamic nature of an object class cannot be easily understood without careful study of the underlying source code. Also, efficient use of inheritance requires that the programmer become familiar with the methods and data of the parent classes all the way up the class hierarchy for every class being used. Thus, although the object-oriented approach goes some way towards enabling computer programs to be built from pre-built components, it requires a high level of programming expertise.
In sum, while each of the above approaches address various aspects of the software development process, none of them solve the underlying problem with the prior art, which is that the development and customization of computer programs requires familiarity with the underlying algorithms and programming instructions. Indeed, in 1999, the report of a Presidential advisory committee stated that the nation has become xe2x80x9cdangerously dependent on large software systems, whose behavior is not well understood and which often fail in unpredicted waysxe2x80x9d. The report recommended that software research be directed toward xe2x80x9ccomponent-based software designxe2x80x9d, as one of four initiatives to receive an increase in federal financing of $1.3 billion over 5 years.
In view of the foregoing, there exists a need in the art for a system and method for software development with the following characteristics: First, computer programs would be built and modified by specifying and combining discrete general-purpose components for which the underlying source code will have already been created and fully tested by software engineers. Second, such components could be specified and combined in a simple and consistent manner so that their relationships are easy to view and modify. Such combinations would be performed in well-defined ways that do not require any additional programming. Third, a mechanism would exist for allowing the full specification of a component to be deferred.
It is an object of the proposed invention to provide a system and method for software development satisfying the above characteristics. This would reduce the need for interaction with source code, thereby reducing the incidence of programming errors. It would also accommodate parts of varying levels of generality. Finally it would permit different users to take advantage of specialization, while freeing them from having to master details that lie beyond their area of expertise or authority.
It is a second object to provide an editing tool for controlling the viewing, specification and combination of such components, such tool having the following features: First, a visual means for modification and combination of components, to take advantage of the human mind""s ability to more easily comprehend complex relationships visually. Second, a mechanism to permit elements of a component to be selectively hidden from view based on certain criteria. Third, a means for controlling how components may be combined and related. Fourth, a means for documenting components. Fifth, a mechanism for organizing components.
These and other objects of the invention are accomplished by a method and system for configuring and executing a computer program. The invention provides a customizable layer above the underlying executable software, which in the preferred embodiment is implemented in an object-oriented environment. The customizable layer is provided through a special type of component specification, defined here as a component interface.
The invention comprises the following elements: First, a collection of component specifications known as component interfaces that may be associated with a computer program, each of which may be comprised of one or more attribute descriptors and one or more summary descriptors. Second, an execution manager comprising (i) a plurality of software components corresponding to the component interfaces and (ii) a component management mechanism for creating and automatically and dynamically managing the relationships interactions between these software components, as specified by the component interfaces. The invention may also incorporate a visual component manager for modifying and combining component interfaces.
As will become clear in the description tat follows, a component interface is self-contained in that it represents a component, together with the information by which that component is related to other component (that are represented by other component interfaces). Some of this information will not be specified until the component interface is combined with other component interfaces. The components represented by component interfaces can take values of many different types including boolean indicator, character stings dates, computer programs, random variables, and time-series.
The general steps for configuring and executing a computer program according to the present invention are as follows: First, each required attribute descriptor of each component interface may be specified using a second component interface via a reciprocating socket associated with that attribute descriptor. The reciprocating socket provides a means to specify any required attribute descriptors in the second component interface that have not yet been specified. According to the preferred embodiment, this step is most efficiently performed using the visual component editor. Next, software components are created according to the information contained in the component interfaces, and relationships between the software components are generated in accordance with the information in the component interfaces. Finally, the execution manager causes the computer program to execute, and the component management mechanism maintains the specified relationships between the software components.
While some component interfaces can be very simple, others can be highly complex, built using hundreds of other component interfaces. Each component interface can be specified by persons with the appropriate subject-matter expertise using component interfaces built by others. Therefore, the term user-expert will henceforth be used to describe all of those who interact with the proposed invention.
Component interfaces provide a means for a user-expert to configure a computer program. Component interfaces can be directly modified and combined by a user-expert and can be represented using a component interface language for storage on a permanent storage device.
Attribute descriptors and summary descriptors provide a means by which various aspects of a component interface may be referenced elsewhere by other component interfaces. Attribute descriptors provide the means by which component interfaces may be varied or customized or used to represent dynamic behavior. Summary descriptors represent items whose values are derived from the component represented by the component interface. Each summary descriptor is in turn associated with its own component interface, a copy of which must be specified in order to reference the derived value.
Each component interface may be specified by a user-expert who is expert in that field. The use of discrete component interfaces enables knowledge and expertise to be precisely focused, leading to more robust and accurate computer programs. This division of knowledge mirrors the real-life environment that computer programs are intended to support. For example, a life insurance agent might create an illustration of an insurance product that has been designed by marketing experts using pricing tables created by actuaries satisfying constraints defined by government lawyers and sold subject to medical constraints established by underwriters.
When a component interface is modified by a user-expert, the present invention can cause the corresponding software component to automatically reflect the modifications when the program is executed. If the range of component interfaces used with the present invention is sufficiently broad, many program modifications could be made without the need for programming.
To fully specify a component interface, it is necessary to fully specify each required attribute descriptor via its reciprocating socket. The reciprocating socket mechanism makes it possible for each fully specified component interface to contain complete information relating to its corresponding software component""s relationships and interactions with other software components. As a result, a component interface can generally be easily detached from a reciprocating socket and replaced, with minimal impact on other component interfaces. This is in contrast with the traditional object oriented approach in which an object is at the center of a web of customized external messages built from customized external parameters, and can often be changed only with great difficulty.
In the preferred embodiment of the present invention, the software components and component management mechanism are combined into a special type of object that is called a dynamic object.
In combination, the partially specified component interfaces, attribute descriptors, summary descriptors and reciprocating sockets of the present invention provide a new way to specify software components and their relationships. This, together with the dynamic objects, provides a number of technical advantages over the prior art.
It will be shown in the description that follows that the present invention provides an intuitive way to specify and combine component interfaces. It also eliminates the need to write specialized programming instructions for instantiating and initializing objects, building object structures, and for setting and resetting the value of an object""s attributes. The dynamic objects of the present invention can implement complex structures of component interfaces using a single general-purpose massaging structure, thereby substantially reducing the need to write customized programming instructions for specifying messages between objects. The present invention also extends the benefits of inheritance and polymorphism directly to user-experts, while being easier to comprehend. Furthermore, the present invention provides a means for organizing component interfaces that is more flexible than that provided by traditional object class hierarchies.
With a sufficiently broad variety of component interfaces, the present invention enables a revolutionary new approach to building and modifying computer programs. The current paradigm of building computer programs by custom programming can be replaced by one in which specialized computer programs are configured from general-purpose computer programs using pre-existing component interfaces. This can be performed directly by the appropriate user-expert, without the intervention of software engineers. As a result, computer programs can be developed and modified more quickly and more reliably and therefore more cheaply.
Component interfaces can be easily adapted to provide a number of advanced capabilities that are impractical or impossible in the prior art, such as versioning, specification of default values and alternative values, and being able to dynamically reflect changes to a component interface whenever it is used.
The visual component manager of the present invention provides an intuitive way for a user-expert to view and modify component interfaces. It also provides a way to control how component interfaces can be specified and combined so that they are free from errors. Furthermore, the visual component manager makes possible a number of additional capabilities that are impractical or impossible in the prior art, such as security authorization, the ability to selectively hide parts of a component interface, and the ability to comprehensively document each attribute descriptor of each component interface associated with a computer program. Finally, the visual component manager supports a mechanism for organizing component interfaces that is more extensive and flexible than that provided by traditional object hierarchies.
With these and other objects, advantages and features of the invention that may become hereinafter apparent, the nature of the invention may be more clearly understood by reference to the following detailed description of the invention, the appended claims and to the several drawings attached herein.